const path = require('path');
const fs = require('fs');
const vscode = require('vscode');
const AgentTools = require('./agentTools');
const ProjectAnalyzer = require('./projectAnalyzer');
const CodeGenerator = require('./codeGenerator');
const AIService = require('./aiService');
const { McpAssistant } = require('../agent/McpAssistant');

/**
 * 代理任务处理器，处理用户任务并通过AI与工具完成
 */
class AgentTask {
    constructor() {
        this.workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
        this.tools = this.workspaceRoot ? new AgentTools(this.workspaceRoot) : null;
        this.analyzer = new ProjectAnalyzer();
        this.generator = new CodeGenerator(this.analyzer);
        this.aiService = new AIService();
        this.activeTaskId = null;
        this.taskHistory = [];
        this.taskContext = {};
        
        // 从设置中读取最大尝试次数，默认为20次
        this.MAX_ATTEMPTS = vscode.workspace.getConfiguration('aiAssistant').get('maxAttempts', 20);
        
        // 用户选择的模型
        this.selectedModel = "qwen-plus";
        
        // 是否启用深度思考
        this.enableReasoning = true; // 默认启用
        
        // 已执行的工具调用集合
        this.executedTools = new Set();
        
        // 自动批准设置
        this.autoApprovalSettings = {
            enabled: true,  // 默认不启用自动批准
            paths: []        // 允许自动批准的路径
        };

        this.waitingForUser = null; // 新增：用于存储等待用户确认的工具调用
        this.mcpAssistant = null; // 添加MCP助手
    }

    async initialize() {
        if (!this.workspaceRoot) {
            throw new Error('未找到工作区文件夹');
        }
        await this.analyzer.initialize(this.workspaceRoot);
        
        // 初始化MCP助手
        try {
            // 获取全局共享的MCP服务实例
            const mcpService = global.getMcpService ? global.getMcpService() : null;
            
            if (!mcpService) {
                // 尝试从扩展API获取MCP服务
                const extension = vscode.extensions.getExtension('xinye.gptdemo');
                if (extension) {
                    const extensionExports = extension.exports || {};
                    if (typeof extensionExports.getMcpService === 'function') {
                        const mcpService = extensionExports.getMcpService();
                        if (mcpService) {
                            this.mcpAssistant = new McpAssistant(mcpService);
                            console.log('MCP助手已通过扩展API初始化');
                        }
                    }
                }
            } else {
                this.mcpAssistant = new McpAssistant(mcpService);
                console.log('MCP助手已通过全局服务初始化');
            }
            
            // 检查初始化结果
            if (this.mcpAssistant) {
                const tools = this.mcpAssistant.getAvailableTools();
                console.log(`已加载 ${tools.length} 个MCP工具`);
            } else {
                console.warn('MCP助手未能初始化，MCP功能将被禁用');
            }
        } catch (error) {
            console.warn('初始化MCP助手失败:', error);
            // 继续执行，MCP功能将被禁用
        }
        
        return this;
    }

    /**
     * 启动新的任务
     * @param {string} query - 用户查询
     * @param {Function} progressCallback - 进度回调函数
     * @param {Array} historyMessages - 可选的历史消息数组
     * @param {Object} options - 额外选项，如深度思考开关状态
     */
    startTask(query, progressCallback, historyMessages = [], options = {}) {
        // 初始化任务上下文
        this.taskContext = {
            workspaceInfo: { root: this.workspaceRoot },
            userPrompt: query,
            messages: [],
            results: [],
            attempts: 0,
            isFirstCall: true  // 新增：标记这是第一次调用
        };
        
        // 明确重置等待用户确认的状态
        this.waitingForUser = null;
        this.executedTools = new Set();
        
        // 设置深度思考开关状态
        if (options.enableReasoning !== undefined) {
            this.enableReasoning = options.enableReasoning;
        }
        
        // 如果有历史消息，先添加到消息上下文中
        if (historyMessages && historyMessages.length > 0) {
            // 处理历史消息，转换为适合AI的格式
            for (const historyMsg of historyMessages) {
                if (historyMsg.sender === 'user') {
                    this.taskContext.messages.push({
                        role: 'user',
                        content: historyMsg.text
                    });
                } else if (historyMsg.sender === 'bot') {
                    this.taskContext.messages.push({
                        role: 'assistant',
                        content: historyMsg.text
                    });
                }
            }
        }

        // 添加用户当前请求到上下文（只添加一次）
        this.taskContext.messages.push({
            role: 'user',
            content: query
        });
        
        // 将选择的模型传递给AIService
        this.aiService.selectedModel = this.selectedModel;
        this.aiService.enableReasoning = this.enableReasoning;
        
        this.currentTaskState = {
            isRunning: true,
            isCompleted: false,
            messageHistory: [], 
            query: query,
            progressCallback: progressCallback || (() => {}),
            partialMessages: new Map()
        };
        
        return new Promise((resolve, reject) => {
            this.currentTaskState.resolve = resolve;
            this.currentTaskState.reject = reject;
            
            this.executeTaskLoop()
                .then(result => {
                    if (this.currentTaskState && this.currentTaskState.resolve) {
                        this.currentTaskState.resolve(result);
                    }
                })
                .catch(error => {
                    console.error('执行任务出错:', error);
                    if (this.currentTaskState && this.currentTaskState.reject) {
                        this.currentTaskState.reject(error);
                    }
                });
        });
    }

    /**
     * 执行任务循环
     */
    async executeTaskLoop() {
        // 通知开始分析
        
        // 重新从配置中读取最大尝试次数，以便实时更新
        this.MAX_ATTEMPTS = vscode.workspace.getConfiguration('aiAssistant').get('maxAttempts', 20);
        
        while (this.taskContext.attempts < this.MAX_ATTEMPTS) {
            try {
                this.taskContext.attempts++;
                
                // 调用AI分析任务并提出下一步行动
                const aiResponse = await this.getNextAction(this.currentTaskState.progressCallback);
                if (!aiResponse.success) {
                    this.currentTaskState.progressCallback({ type: 'error', message: `AI响应错误: ${aiResponse.error}` });
                    return { success: false, error: aiResponse.error };
                }
    
                // 检查是否等待用户确认
                if (this.waitingForUser) {
                    console.log("等待用户操作中，暂停任务循环");
                    // 暂停循环，等待用户操作
                    await new Promise((resolve) => {
                        this.waitingForUser.resume = resolve;
                    });
                }
    
                // 如果任务已完成，则退出循环
                if (this.currentTaskState.isCompleted) {
                    console.log("任务已在工具处理过程中完成，退出循环");
                    return {
                        success: true,
                        results: this.taskContext.results,
                        summary: '任务已完成'
                    };
                }
                
                // 处理MCP工具调用
                if (this._pendingMcpResponse) {
                    console.log("检测到待处理的MCP响应，进行处理");
                    // 处理MCP响应
                    const processedResponse = await this._processPendingMcpResponse();
                    
                    if (processedResponse) {
                        // 如果有MCP工具执行结果，添加到上下文
                        this.taskContext.messages.push({
                            role: 'assistant',
                            content: processedResponse
                        });
                        
                        // 通知前端
                        this.currentTaskState.progressCallback({
                            type: 'system',
                            message: 'MCP工具执行完成，继续任务'
                        });
                        
                        // 继续任务循环
                        continue;
                    }
                }
                
                // 分析响应内容，检查是否需要继续任务
                const parsedContent = this.parseAssistantMessage(aiResponse.response);
                const hasCompletionTool = parsedContent.toolCalls.some(tool => tool.name === 'attempt_completion');
                
                if (hasCompletionTool) {
                    // 任务已完成，退出循环
                    this.currentTaskState.isCompleted = true;
                    console.log("检测到任务完成标记，退出循环");
                    return {
                        success: true,
                        results: this.taskContext.results,
                        summary: parsedContent.textBlocks.length > 0 ? parsedContent.textBlocks[0].content : '任务已完成'
                    };
                }
            } catch (error) {
                console.error("执行任务循环出错:", error);
                this.currentTaskState.progressCallback({ 
                    type: 'error', 
                    message: `执行任务出错: ${error.message}` 
                });
            }
        }

        // 再次从配置中读取最大尝试次数，确保使用最新设置
        this.MAX_ATTEMPTS = vscode.workspace.getConfiguration('aiAssistant').get('maxAttempts', 20);
        
        // 检查是否真的达到最大尝试次数
        if (this.taskContext.attempts >= this.MAX_ATTEMPTS) {
            this.currentTaskState.progressCallback({ type: 'warning', message: `达到最大尝试次数(${this.MAX_ATTEMPTS})，任务终止` });
            return { 
                success: false, 
                error: `达到最大尝试次数(${this.MAX_ATTEMPTS})`,
                results: this.taskContext.results
            };
        } else {
            // 如果尝试次数设置被增加，继续执行
            return this.executeTaskLoop();
        }
    }

    // 获取工具的展示名称
    getToolDisplayName(toolName) {
        const displayNames = {
            'write_to_file': '写入文件',
            'read_file': '读取文件',
            'replace_in_file': '替换文件内容',
            'search_files': '搜索文件',
            'search_text': '搜索文本',
            'list_files': '列出文件',
            'execute_command': '执行命令',
            'create_directory': '创建目录',
            'delete_file': '删除文件',
            'rename_file': '重命名文件',
            'show_options': '展示选项',
            'attempt_completion': '完成任务'
        };
        
        return displayNames[toolName] || toolName;
    }

    /**
     * 在getNextAction中处理待处理的MCP响应
     * @private
     */
    async _processPendingMcpResponse() {
        if (this._pendingMcpResponse && this.mcpAssistant) {
            try {
                console.log('开始处理MCP响应...');
                const response = this._pendingMcpResponse.response;
                const { processedResponse, toolResults } = await this.mcpAssistant.processMcpResponse(
                    response,
                    (toolName, params, callback, serverName) => {
                        // 实现用户批准请求 - 使用mcpToolApproval类型专门处理MCP工具调用
                        // 直接调用回调函数，不使用sendPartialMessage避免可能的无限递归
                        if (this.currentTaskState && this.currentTaskState.progressCallback) {
                            this.currentTaskState.progressCallback({
                                type: 'mcpToolApproval',
                                toolName,
                                serverName,
                                params
                            });
                        } else {
                            console.warn('进度回调不可用，无法发送MCP工具批准请求');
                        }
                        
                        // 存储回调函数以供handleUserApproval使用
                        this._lastMcpApprovalCallback = callback;
                    }
                );
                
                // 如果有工具调用结果，使用处理后的响应
                if (toolResults.length > 0) {
                    // 记录工具调用结果
                    for (const result of toolResults) {
                        const { call, result: toolResult, error } = result;
                        if (error) {
                            console.error(`MCP工具执行失败: ${call.serverName}.${call.toolName}`, error);
                            // 添加失败的工具调用结果到上下文
                            this.taskContext.messages.push({
                                role: 'function',
                                content: JSON.stringify({
                                    type: 'mcp_tool_result',
                                    serverName: call.serverName,
                                    toolName: call.toolName,
                                    params: call.params,
                                    success: false,
                                    error: error.message || String(error)
                                })
                            });
                            
                            // 向前端发送MCP工具执行失败消息
                            this.currentTaskState.progressCallback({
                                type: 'mcpToolResult',
                                serverName: call.serverName,
                                toolName: call.toolName,
                                success: false,
                                error: error.message || String(error)
                            });
                        } else {
                            console.log(`MCP工具执行成功: ${call.serverName}.${call.toolName}`, toolResult);
                            // 添加成功的工具调用结果到上下文
                            this.taskContext.messages.push({
                                role: 'function',
                                content: JSON.stringify({
                                    type: 'mcpToolResult',
                                    serverName: call.serverName,
                                    toolName: call.toolName,
                                    params: call.params,
                                    success: true,
                                    result: toolResult
                                })
                            });
                            
                            // 向前端发送MCP工具执行成功消息
                            this.currentTaskState.progressCallback({
                                type: 'mcpToolResult',
                                serverName: call.serverName,
                                toolName: call.toolName,
                                success: true,
                                result: toolResult
                            });
                        }
                    }
                    
                    // 通知用户工具已执行
                    this.currentTaskState.progressCallback({
                        type: 'system',
                        message: `已执行${toolResults.length}个MCP工具调用`
                    });
                    
                    // 解决pendingMcpResponse
                    const resolvedResponse = processedResponse;
                    
                    // 清除待处理响应
                    this._pendingMcpResponse = null;
                    
                    // 返回处理后的响应内容
                    return resolvedResponse;
                }
                
                // 清除待处理响应
                this._pendingMcpResponse = null;
            } catch (error) {
                console.error('处理MCP响应失败:', error);
                // 出错时清除待处理响应
                this._pendingMcpResponse = null;
                
                // 通知用户错误
                this.currentTaskState.progressCallback({
                    type: 'error',
                    message: `处理MCP工具调用出错: ${error.message || String(error)}`
                });
                
                // 添加错误信息到上下文
                this.taskContext.messages.push({
                    role: 'system',
                    content: `处理MCP工具调用出错: ${error.message || String(error)}`
                });
            }
        }
        
        return null;
    }

    /**
     * 获取下一个操作
     * @param {Function} progressCallback - 进度回调函数
     * @returns {Promise<Object>} - 操作结果
     */
    async getNextAction(progressCallback) {
        try {
            // 为每个消息生成唯一ID
            const partialMessageId = `msg_${Date.now()}`;
            
            // 生成系统提示词
            const systemPrompt = this.buildSystemPrompt();
            
            // 存储当前响应
            let aiResponse = '';
            
            // 创建部分消息，UI将使用此标识符更新消息
            this.sendPartialMessage({
                id: partialMessageId,
                role: 'assistant',
                content: '',
                partial: true
            }, progressCallback);
            
            // 准备传递给AI的消息
            let messagesForAI = [...this.taskContext.messages];
            
            // 如果不是第一次调用，移除初始用户请求，添加系统消息指示继续任务
            if (!this.taskContext.isFirstCall) {
                // 找到第一个用户输入的索引，移除它
                const firstUserMsgIndex = messagesForAI.findIndex(msg => msg.role === 'user' && typeof msg.content === 'string');
                if (firstUserMsgIndex >= 0) {
                    messagesForAI.splice(firstUserMsgIndex, 1);
                }
                
                // 添加一个系统消息，指示AI根据当前进度继续任务
                messagesForAI.push({
                    role: 'system',
                    content: '请根据历史操作和当前进度，继续完成任务。不要重复已执行的步骤，专注于下一步操作。'
                });
            } else {
                // 标记为非第一次调用，这样下次就不会将初始用户请求传递给AI
                this.taskContext.isFirstCall = false;
            }
            
            // 处理待处理的MCP响应
            const processedMcpResponse = await this._processPendingMcpResponse();
            if (processedMcpResponse) {
                // 如果有处理后的MCP响应，使用它替换最后一个助手消息
                // 从后向前找到最后一个助手消息
                let lastAssistantMessageIndex = -1;
                for (let i = messagesForAI.length - 1; i >= 0; i--) {
                    if (messagesForAI[i].role === 'assistant') {
                        lastAssistantMessageIndex = i;
                        break;
                    }
                }
                
                if (lastAssistantMessageIndex >= 0) {
                    messagesForAI[lastAssistantMessageIndex].content = processedMcpResponse;
                }
            }
            
            // 确保AI理解如何使用MCP工具
            if (this.mcpAssistant) {
                // 添加一个额外的系统消息，提醒AI可以使用MCP工具
                messagesForAI.push({
                    role: 'system',
                    content: `记住，你可以使用MCP工具来完成任务。使用<mcp-tool server="服务器名称" tool="工具名称" params={...参数...}></mcp-tool>格式调用工具。`
                });
            }
            
            // 检查消息大小并进行优化
            messagesForAI = this._optimizeMessagesSize(messagesForAI, systemPrompt);
            
            // 处理流式响应，使用回调函数接收数据块
            await this.aiService.createMessage(
                systemPrompt, 
                messagesForAI,
                (chunk) => {
                    console.log(`接收到数据块: ${chunk === null ? 'null' : chunk}`);
                    
                    // 处理null或undefined值
                    if (chunk === null || chunk === undefined) {
                        console.warn("接收到空数据块，跳过处理");
                        return;
                    }
                    
                    // 检查是否是流结束标记
                    if (chunk === "STREAM_END") {
                        // 流结束，发送完整消息
                        this.sendPartialMessage({
                            id: partialMessageId,
                            role: 'assistant',
                            content: aiResponse,
                            partial: false
                        }, progressCallback);
                        
                        return;
                    }
                    
                    // 检查是否是思考过程内容
                    if (typeof chunk === 'string' && chunk.startsWith("THINKING:")) {
                        // 提取思考过程内容
                        const thinkingContent = chunk.substring(9); // 去掉"THINKING:"前缀
                        
                        // 发送思考过程给前端显示（使用特殊类型标记）
                        progressCallback({ 
                            type: 'thinking', 
                            message: thinkingContent 
                        });
                        
                        // 不将思考过程添加到最终响应
                        return;
                    }
                    
                    // 检查是否是思考过程结束标记
                    if (chunk === "THINKING_END") {
                        // 通知前端思考过程结束
                        progressCallback({
                            type: 'thinking_end',
                            message: ''
                        });
                        
                        // 不将思考结束标记添加到最终响应
                        return;
                    }
                    
                    // 处理文本块
                    // 处理可能的HTML实体转义
                    const unescapedText = this.unescapeHtml(chunk);
                    
                    // 累积响应
                    aiResponse += unescapedText;
                    
                    // 解析混合内容
                    const parsedContent = this.parseAssistantMessage(aiResponse);
                    
                    // 更新部分消息
                    this.sendPartialMessage({
                        id: partialMessageId,
                        role: 'assistant',
                        content: aiResponse,
                        partial: true
                    }, progressCallback);
                    
                    // 发送给前端显示
                    progressCallback({ 
                        type: 'ai', 
                        message: unescapedText 
                    });
                            
                    // 检查是否有完整的工具调用需要自动执行
                    this.checkAndAutoExecuteTools(parsedContent, partialMessageId, progressCallback);
                }
            );

            // 记录当前任务ID以支持停止
            this.activeTaskId = partialMessageId;

            // 添加AI响应到上下文
            this.taskContext.messages.push({
                role: 'assistant',
                content: aiResponse
            });

            // 存储AI响应结果到上下文
            this.taskContext.results.push({
                type: 'ai_response',
                content: aiResponse,
                timestamp: new Date().toISOString()
            });

            // 处理可能的MCP工具调用
            this._checkForMcpToolCalls(aiResponse);

            return { success: true, response: aiResponse };
        } catch (error) {
            return { success: false, error: error.message };
        }
    }
    
    /**
     * 优化消息大小，防止超出限制
     * @param {Array} messages - 消息数组
     * @param {string} systemPrompt - 系统提示词
     * @returns {Array} - 优化后的消息数组
     * @private
     */
    _optimizeMessagesSize(messages, systemPrompt) {
        // 估算当前大小
        let systemPromptSize = systemPrompt.length;
        
        // 创建消息副本以防修改原始数据
        let optimizedMessages = [...messages];
        
        // 计算当前消息总大小
        let totalSize = systemPromptSize;
        let messageSizes = [];
        
        for (let i = 0; i < optimizedMessages.length; i++) {
            const msg = optimizedMessages[i];
            const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
            const size = content.length;
            totalSize += size;
            messageSizes.push({ index: i, size, role: msg.role });
        }
        
        // 估算token数 (粗略估计为字符数/4)
        const estimatedTokens = Math.ceil(totalSize / 4);
        console.log(`[消息优化] 当前估计大小: ${totalSize} 字符, 约 ${estimatedTokens} tokens`);
        
        // 设置最大允许token (留出一些余量)
        const MAX_ALLOWED_TOKENS = 90000; // 限制在90k以下，给回复留出空间
        
        // 如果当前大小超过限制，进行优化
        if (estimatedTokens > MAX_ALLOWED_TOKENS) {
            console.log(`[消息优化] 消息大小超过限制，进行优化`);
            
            // 按照优先级排序消息 (保留最近和最重要的)
            // 优先级: 系统消息 > 最近的用户输入 > 最近的AI回复 > 旧消息
            
            // 1. 保留必要的系统消息和最近的消息
            const keepMessages = [];
            const removeMessages = [];
            
            // 1.1 排序消息 - 系统消息、功能消息等放最后
            messageSizes.sort((a, b) => {
                // 保持系统消息优先级高
                if (a.role === 'system' && b.role !== 'system') return -1;
                if (a.role !== 'system' && b.role === 'system') return 1;
                
                // 其次是最近的用户消息
                if (a.role === 'user' && b.role !== 'user') return -1;
                if (a.role !== 'user' && b.role === 'user') return 1;
                
                // 再次是助手消息
                if (a.role === 'assistant' && b.role !== 'assistant') return -1;
                if (a.role !== 'assistant' && b.role === 'assistant') return 1;
                
                // 默认从新到旧排序
                return b.index - a.index;
            });
            
            // 1.2 添加消息直到接近大小限制
            let currentSize = systemPromptSize;
            
            for (const msg of messageSizes) {
                if (currentSize + msg.size < MAX_ALLOWED_TOKENS * 4) {
                    keepMessages.push(msg.index);
                    currentSize += msg.size;
                } else {
                    removeMessages.push(msg.index);
                }
            }
            
            // 按照原始顺序排序保留的消息
            keepMessages.sort((a, b) => a - b);
            
            // 2. 创建优化后的消息数组
            const newMessages = keepMessages.map(idx => optimizedMessages[idx]);
            
            // 3. 如果移除了消息，添加一个摘要说明
            if (removeMessages.length > 0) {
                console.log(`[消息优化] 移除了 ${removeMessages.length} 条旧消息以减小大小`);
                
                // 添加一个摘要消息，说明移除了一些历史消息
                newMessages.unshift({
                    role: 'system',
                    content: `注意：为了优化性能，${removeMessages.length} 条较早的历史消息已被压缩。请继续基于可见的历史消息完成任务。`
                });
            }
            
            // 重新计算优化后的大小
            let newTotalSize = systemPromptSize;
            for (const msg of newMessages) {
                const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
                newTotalSize += content.length;
            }
            const newEstimatedTokens = Math.ceil(newTotalSize / 4);
            
            console.log(`[消息优化] 优化后大小: ${newTotalSize} 字符, 约 ${newEstimatedTokens} tokens`);
            
            return newMessages;
        }
        
        // 如果大小在限制内，直接返回原始消息
        return optimizedMessages;
    }

    /**
     * 检查AI响应中的MCP工具调用
     * @private
     */
    _checkForMcpToolCalls(aiResponse) {
        if (this.mcpAssistant) {
            // 标记响应为需要处理
            this._pendingMcpResponse = {
                response: aiResponse,
                timestamp: Date.now()
            };
            console.log('已标记MCP响应等待处理');
        }
    }

    /**
     * 检查并自动执行工具调用
     * @param {Object} parsedContent - 解析后的内容
     * @param {string} messageId - 消息ID
     * @param {Function} progressCallback - 进度回调函数
     */
    async checkAndAutoExecuteTools(parsedContent, messageId, progressCallback) {
        // 如果启用了自动执行工具
        console.log(`工具调用数量: ${parsedContent.toolCalls.length}`);
        if (this.autoApprovalSettings?.enabled && parsedContent.toolCalls) {
            // 检查是否包含高风险操作
            const highRiskTools = parsedContent.toolCalls.filter(tool => 
                tool.name === 'delete_file' || tool.name === 'execute_command' || tool.name === 'show_options'
            );

            // 如果有多个高风险操作，只处理第一个
            if (highRiskTools.length > 1) {
                console.log('检测到多个高风险操作，只处理第一个');
                // 过滤工具列表，只保留第一个高风险操作和其他非高风险操作
                const filteredTools = parsedContent.toolCalls.filter((tool, index) => {
                    if (tool.name === 'delete_file' || tool.name === 'execute_command' || tool.name === 'show_options') {
                        return index === parsedContent.toolCalls.findIndex(t => 
                            t.name === 'delete_file' || t.name === 'execute_command' || t.name === 'show_options'
                        );
                    }
                    return true;
                });
                parsedContent.toolCalls = filteredTools;
            }

            // 创建一个数组来存储所有工具执行的 Promise
            const toolExecutionPromises = [];
            
            // 记录是否遇到了需要用户确认的操作
            let hasUserApprovalOperation = false;

            for (let i = 0; i < parsedContent.toolCalls.length; i++) {
                const toolCall = parsedContent.toolCalls[i];
                console.log(`处理工具: ${toolCall.name}, 参数:`, toolCall.params);
                
                // 检查工具是否已执行过
                if (!toolCall.name || this.executedTools.has(`${messageId}_${i}`)) {
                    console.log(`工具 ${toolCall.name} 已执行过或无效，跳过`);
                    continue;
                }

                // 检查是否是高风险操作
                const isHighRiskTool = toolCall.name === 'delete_file' || toolCall.name === 'execute_command' || toolCall.name === 'show_options';
                
                // 如果已经遇到了需要用户确认的操作，跳过后续工具
                if (hasUserApprovalOperation) {
                    console.log(`已有待确认操作，跳过工具 ${toolCall.name}`);
                    continue;
                }

                // 标记为已执行
                this.executedTools.add(`${messageId}_${i}`);
                
                // 检查是否是任务完成工具调用
                if (toolCall.name === 'attempt_completion') {
                    this.currentTaskState.progressCallback({ type: 'system', message: '任务完成' });
                    this.currentTaskState.isCompleted = true;
                    if (this.currentTaskState && this.currentTaskState.resolve) {
                        this.currentTaskState.resolve({ 
                            success: true, 
                            results: this.taskContext.results,
                            summary: parsedContent.textBlocks.length > 0 ? parsedContent.textBlocks[0].content : '任务已完成'
                        });
                    }
                    return true;
                }
                
                // 创建一个异步执行工具的 Promise
                const toolExecutionPromise = (async () => {
                    this.currentTaskState.progressCallback({ 
                        type: 'system', 
                        message: `正在执行操作: ${this.getToolDisplayName(toolCall.name)}` 
                    });
                    
                    const result = await this.executeToolCall(toolCall);
                    
                    if (!result.success) {
                        this.currentTaskState.progressCallback({ 
                            type: 'error', 
                            message: `工具执行失败: ${this.getToolDisplayName(toolCall.name)} - ${result.error}` 
                        });
                    } else {
                        this.currentTaskState.progressCallback({ 
                            type: 'success', 
                            message: `工具执行成功: ${this.getToolDisplayName(toolCall.name)}` 
                        });
                    }
                    
                    // 添加工具响应到上下文
                    this.taskContext.results.push({
                        tool: toolCall.name,
                        params: toolCall.params,
                        result: result
                    });
                    
                    // 添加到消息历史
                    this.taskContext.messages.push({
                        role: 'user',
                        content: JSON.stringify({
                            tool: toolCall.name,
                            result: result
                        })
                    });
                    
                    // 如果是高风险操作，标记需要用户确认
                    if (isHighRiskTool) {
                        hasUserApprovalOperation = true;
                    }
                    
                    return { toolCall, result };
                })();
                
                toolExecutionPromises.push(toolExecutionPromise);
            }
            
            // 等待所有工具执行完成
            if (toolExecutionPromises.length > 0) {
                try {
                    const results = await Promise.all(toolExecutionPromises);
                    
                    // 等待一小段时间确保上下文更新完成
                    await new Promise(resolve => setTimeout(resolve, 100));

                    // 检查results是否存在且为数组
                    if (!results || !Array.isArray(results) || results.length === 0) {
                        console.log('没有任何工具执行结果');
                        return false;
                    }

                    // 检查是否有需要用户确认的操作
                    const hasHighRiskOperation = results.some(({ toolCall }) => 
                        toolCall && (
                            toolCall.name === 'delete_file' || 
                            toolCall.name === 'execute_command' ||
                            toolCall.name === 'show_options'
                        )
                    );

                    if (hasHighRiskOperation) {
                        console.log('检测到高风险操作，等待用户确认');
                        return false;
                    }

                    // 检查是否所有操作都成功
                    const allSuccessful = results.every(({ result }) => result.success);
                    if (!allSuccessful) {
                        console.log('部分操作失败，等待下一次调用');
                        return false;
                    }

                } catch (error) {
                    console.error('工具执行出错:', error);
                    this.currentTaskState.progressCallback({ 
                        type: 'error', 
                        message: `工具执行出错: ${error.message}` 
                    });
                    return false;
                }
            } else {
                console.log('没有需要执行的工具');
            }
        }
        return false;
    }

    /**
     * 发送部分消息更新
     * @param {Object} message - 消息对象
     * @param {Function} progressCallback - 进度回调函数
     */
    sendPartialMessage(message, progressCallback) {
        // 存储或更新部分消息
        this.currentTaskState.partialMessages.set(message.id, message);
        
        // 通知UI更新部分消息
        progressCallback({
            type: 'partialMessage',
            message: message
        });
    }

    /**
     * 反转义HTML实体
     * @param {string} text - 包含HTML实体的文本
     * @returns {string} - 反转义后的文本
     */
    unescapeHtml(text) {
        if (!text) return '';
        
        return text
            .replace(/&lt;/g, '<')
            .replace(/&gt;/g, '>')
            .replace(/&amp;/g, '&')
            .replace(/&quot;/g, '"')
            .replace(/&#39;/g, "'")
            .replace(/&nbsp;/g, ' ');
    }

    /**
     * 解析AI助手消息，将其分解为文本块和工具调用块
     * @param {string} assistantMessage - AI助手回复的原始消息
     * @returns {{toolCalls: Array, textBlocks: Array}} - 解析后的内容块对象
     */
    parseAssistantMessage(assistantMessage) { 
        // 首先反转义HTML实体 
        assistantMessage = this.unescapeHtml(assistantMessage); 
        
        const contentBlocks = {toolCalls: [], textBlocks: []}; 
        let currentText = ""; 
        let inToolCall = false;
        let currentToolUse = null; 
        let currentParamName = null; 
        
        // 获取支持的工具和参数名列表 
        const toolUseNames = [ 
            'write_to_file', 'read_file', 'replace_in_file', 
            'search_files', 'search_text', 'list_files', 'execute_command', 
            'create_directory', 'delete_file', 'rename_file', 
            'show_options', 'attempt_completion' 
        ]; 
        
        const toolParamNames = [ 
            'path', 'content', 'old_text', 'new_text', 'pattern', 
            'directory', 'recursive', 'command', 'requires_approval', 
            'old_path', 'new_path', 'text', 'file_pattern', 'options', 
            'message', 'summary' 
        ]; 
    
        // 逐字符解析消息 
        let i = 0;
        while (i < assistantMessage.length) {
            // 检查是否开始工具调用
            if (!inToolCall) {
                let foundToolStart = false;
                for (const toolName of toolUseNames) {
                    const tagStart = `<${toolName}>`;
                    if (assistantMessage.substring(i, i + tagStart.length) === tagStart) {
                        // 如果有累积的文本，添加到文本块
                        if (currentText.trim()) {
                            contentBlocks.textBlocks.push({
                                type: 'text',
                                content: currentText.trim()
                            });
                        }
                        
                        // 开始新的工具调用
                        currentToolUse = {
                            type: 'tool_use',
                            name: toolName,
                            params: {}
                        };
                        
                        inToolCall = true;
                        currentText = "";
                        i += tagStart.length;
                        foundToolStart = true;
                        break;
                    }
                }
                
                if (foundToolStart) continue;
                
                // 不是工具调用开始，检查是否是MCP工具调用开始
                if (assistantMessage.substring(i, i + 9) === '<mcp-tool') {
                    // 查找MCP工具结束标签
                    const mcpEndPos = assistantMessage.indexOf('</mcp-tool>', i);
                    if (mcpEndPos > i) {
                        // 找到完整的MCP工具调用，提取整个标签
                        const mcpToolCall = assistantMessage.substring(i, mcpEndPos + 11); // 11 是 </mcp-tool> 的长度
                        
                        // 如果有累积的文本，添加到文本块
                        if (currentText.trim()) {
                            contentBlocks.textBlocks.push({
                                type: 'text',
                                content: currentText.trim()
                            });
                        }
                        
                        // 标记为需要处理的MCP内容
                        if (this.mcpAssistant) {
                            this._pendingMcpResponse = {
                                response: assistantMessage,
                                timestamp: Date.now()
                            };
                            
                            console.log('解析到MCP工具调用:', mcpToolCall);
                        }
                        
                        // 跳过整个标签
                        i = mcpEndPos + 11;
                        currentText = "";
                        continue;
                    }
                }
                
                // 不是工具调用开始，累积文本
                currentText += assistantMessage[i];
                i++;
                continue;
            }
            
            // 在工具调用内部
            // 检查是否是工具调用结束
            const toolEndTag = `</${currentToolUse.name}>`;
            if (assistantMessage.substring(i, i + toolEndTag.length) === toolEndTag) {
                // 工具调用结束
                contentBlocks.toolCalls.push(currentToolUse);
                inToolCall = false;
                currentToolUse = null;
                currentParamName = null;
                currentText = "";
                i += toolEndTag.length;
                continue;
            }
            
            // 检查是否开始参数
            if (!currentParamName) {
                let foundParamStart = false;
                for (const paramName of toolParamNames) {
                    const paramStartTag = `<${paramName}>`;
                    if (assistantMessage.substring(i, i + paramStartTag.length) === paramStartTag) {
                        currentParamName = paramName;
                        i += paramStartTag.length;
                        foundParamStart = true;
                        break;
                    }
                }
                
                if (foundParamStart) continue;
                
                // 不是参数开始，跳过这个字符
                i++;
                continue;
            }
            
            // 在参数内部
            // 检查是否是参数结束
            const paramEndTag = `</${currentParamName}>`;
            if (assistantMessage.substring(i, i + paramEndTag.length) === paramEndTag) {
                // 参数结束
                currentToolUse.params[currentParamName] = currentText.trim();
                currentParamName = null;
                currentText = "";
                i += paramEndTag.length;
                continue;
            }
            
            // 累积参数值
            currentText += assistantMessage[i];
            i++;
        }
        
        // 处理最后可能剩余的文本
        if (!inToolCall && currentText.trim()) {
            contentBlocks.textBlocks.push({
                type: 'text',
                content: currentText.trim()
            });
        }
        
        return contentBlocks;
    }

    /**
     * 执行工具调用
     * @param {Object} toolCall - 工具调用对象
     */
    async executeToolCall(toolCall) {
        const { name, params } = toolCall;
        
        // 需要用户确认的高风险操作
        const dangerousTools = [
            'execute_command', 'delete_file'
        ];
        if (dangerousTools.includes(name)) {
            // 发送确认请求到前端（或弹窗），暂停任务循环，等待用户响应
            this.currentTaskState.progressCallback({
                type: 'userApproval',
                toolName: name,
                params: params,
                path: params.path
            });
            // 标记为等待用户
            this.waitingForUser = {
                toolCall,
                resolve: null,
                resume: null,
                result: null
            };
            // 等待用户响应
            const result = await new Promise((resolve) => {
                this.waitingForUser.resolve = resolve;
            });
            this.waitingForUser = null;
            return result;
        }
        
        // 处理展示选项工具（需要暂停等待用户选择）
        if (name === 'show_options') {
            // 发送选项请求到前端
            this.currentTaskState.progressCallback({
                type: 'showOptions',
                message: params.message || "请选择一个选项",
                options: params.options || []
            });
            
            // 标记为等待用户
            this.waitingForUser = {
                toolCall,
                resolve: null,
                resume: null,
                result: null
            };
            
            // 等待用户选择
            const result = await new Promise((resolve) => {
                this.waitingForUser.resolve = resolve;
            });
            this.waitingForUser = null;
            return result;
        }
        
        try {
            switch (name) {
                case 'write_to_file':
                    // 检查是否是JSON文件
                    const isJsonFile = params.path.toLowerCase().endsWith('.json');
                    let content = params.content;
                    
                    if (isJsonFile) {
                        try {
                            // 如果内容是字符串形式的JSON，先解析再格式化
                            if (typeof content === 'string') {
                                // 移除可能存在的转义字符
                                content = content.replace(/\\n/g, '\n')
                                                .replace(/\\"/g, '"')
                                                .replace(/\\t/g, '\t');
                                
                                // 尝试解析JSON
                                const jsonObj = JSON.parse(content);
                                // 重新格式化为美观的JSON
                                content = JSON.stringify(jsonObj, null, 2);
                            }
                        } catch (e) {
                            console.warn('JSON解析失败，将按原样写入:', e);
                        }
                    }
                    
                    return await this.tools.writeToFile(params.path, content);
                    
                case 'read_file':
                    return await this.tools.readFile(params.path);
                    
                case 'replace_in_file':
                    return await this.tools.replaceInFileWithDiff(params.path, params.old_text, params.new_text);
                    
                case 'search_files':
                    return await this.tools.searchFiles(params.pattern, params.directory, params.recursive === 'true');
                    
                case 'search_text':
                    return await this.tools.searchText(params.text, params.file_pattern, params.directory, params.recursive === 'true');
                    
                case 'list_files':
                    return await this.tools.listFiles(params.directory, params.recursive === 'true');
                    
                case 'execute_command':
                    return await this.tools.executeCommand(params.command);
                
                case 'create_directory':
                    return await this.tools.createDirectory(params.path);
                
                case 'delete_file':
                    return await this.tools.deleteFile(params.path);
                
                case 'rename_file':
                    return await this.tools.renameFile(params.old_path, params.new_path);
                    
                case 'show_options':
                    return await this.tools.showOptionsToUser(params.options, params.message);
                    
                case 'attempt_completion':
                    return { success: true, message: '任务完成' };
                    
                default:
                    return { success: false, error: `未知的工具调用: ${name}` };
            }
        } catch (error) {
            return { success: false, error: error.message };
        }
    }

    /**
     * 获取对话上下文历史记录
     * @returns {Array} - 对话上下文历史记录
     */
    getConversationHistory() {
        return this.taskContext.messages || [];
    }

    /**
     * 清除对话上下文历史记录
     */
    clearConversationHistory() {
        // 保留工作区信息和用户提示，清除消息和结果
        this.taskContext = {
            workspaceInfo: this.taskContext.workspaceInfo,
            userPrompt: '', // 清空当前用户提示
            messages: [],   // 清空所有消息历史
            results: [],    // 清空所有结果
            attempts: 0     // 重置尝试次数
        };
        
        // 返回true表示成功清除
        return true;
    }

    /**
     * 获取当前活动编辑器信息
     * @returns {Object} 活动编辑器信息
     */
    getActiveEditorInfo() {
        const editor = vscode.window.activeTextEditor;
        if (!editor) {
            return null;
        }

        const document = editor.document;
        const selection = editor.selection;
        const selectedText = document.getText(selection);

        return {
            fileName: document.fileName,
            language: document.languageId,
            selection: {
                start: selection.start,
                end: selection.end,
                text: selectedText
            },
            content: document.getText(),
            lineCount: document.lineCount,
            isDirty: document.isDirty,
            isUntitled: document.isUntitled
        };
    }

    /**
     * 构建系统提示
     */
    buildSystemPrompt() {
        // 获取活动编辑器信息
        const activeEditor = this.getActiveEditorInfo();
        const editorInfo = activeEditor ? `
当前活动编辑器信息：
- 文件名：${activeEditor.fileName}
- 语言：${activeEditor.language}
- 总行数：${activeEditor.lineCount}
- 是否已修改：${activeEditor.isDirty ? '是' : '否'}
- 是否未保存：${activeEditor.isUntitled ? '是' : '否'}
${activeEditor.selection.text ? `- 选中文本：\n\`\`\`${activeEditor.language}\n${activeEditor.selection.text}\n\`\`\`` : ''}
` : '当前没有活动的编辑器';

        // 获取历史消息数量
        const historyCount = this.taskContext.messages ? this.taskContext.messages.length : 0;
        const lastMessages = this.taskContext.messages ? this.taskContext.messages.slice(-2) : [];
        const lastToolCalls = this.taskContext.results ? this.taskContext.results.filter(r => r.tool).slice(-2) : [];

        // 添加历史上下文分析
        const historyContext = historyCount > 0 ? `
历史上下文分析：
- 已有对话轮次：${historyCount}
- 最近工具调用：${lastToolCalls.map(tc => tc.tool).join(', ')}
- 最近工具调用结果：${lastToolCalls.map(tc => tc.result.success ? '成功' : '失败').join(', ')}
` : '这是新的对话开始';

        // 获取当前任务进度信息
        const isFirstCall = this.taskContext.isFirstCall;
        const progressInfo = !isFirstCall ? `
## 当前任务进度
- 你正在继续执行任务，而不是开始新任务
- 请分析之前的操作历史，确定下一步行动
- 不要重复已完成的操作
- 专注于推进任务直到完成
- 如果任务已完成，使用attempt_completion工具标记任务完成
- 当前尝试次数: ${this.taskContext.attempts}/${this.MAX_ATTEMPTS}，请尽量在剩余尝试次数内完成任务

用户的初始请求是：${this.taskContext.userPrompt}
` : '';

        // 添加MCP工具描述
        let mcpToolsDescription = '';
        if (this.mcpAssistant) {
            try {
                // 获取可用MCP工具数量
                const availableTools = this.mcpAssistant.getAvailableTools();
                if (availableTools && availableTools.length > 0) {
                    mcpToolsDescription = this.mcpAssistant.buildMcpToolsDescription();
                    console.log(`添加MCP工具描述，共 ${availableTools.length} 个工具`);
                } else {
                    console.warn('没有可用的MCP工具');
                }
            } catch (error) {
                console.error('构建MCP工具描述失败:', error);
            }
        }
        
        // 将MCP工具描述添加到系统提示中
        const systemPrompt = `你是一个专业的代码助手，将使用工具帮助用户分析需求并实现功能。请严格遵循以下规则：
核心规则:一次只能调用一个工具，立刻结束并等待结果，不要进行脱离用户需求的深层次操作，需要用户确认时使用show_options工具，需要用户输入时使用attempt_completion工具，不能直接停止

特别注意：
1. 路径使用规范：
   - 所有文件路径必须是相对于工作区根目录的路径
   - 不要使用绝对路径
   - 路径分隔符使用正斜杠(/)
   - 示例：使用 "src/main.js" 而不是 "D:/project/src/main.js"

2. 搜索失败处理：
   - 如果search_files或search_text工具没有找到结果
   - 使用list_files工具查看目录结构
   - 根据目录结构重新调整搜索策略
   - 不要在没有确认文件存在的情况下继续操作

3. 工具类型区分：
   - 系统工具：以<工具名>...</工具名>格式调用的工具（如<read_file>...</read_file>）
   - MCP工具：以<mcp-tool>...</mcp-tool>格式调用的工具
   - 根据任务需求选择合适的工具类型
   - 优先使用系统工具处理文件操作、代码生成等基础任务
   - 只在系统工具无法满足需求时使用MCP工具
   - 不要混淆两种工具的调用格式

4. 回复格式要求：
   - 每次回复必须包含文字说明，不能只调用工具
   - 在调用工具前，必须用文字说明这步要做什么
   - 在调用工具后，必须用文字说明工具执行的结果
   - 回复格式为：文字说明 -> 工具调用 -> 文字说明结果
   - 不要只输出工具调用，必须包含完整的文字说明

5. 工具使用限制：
   - 你只能使用下面明确列出的工具
   - 不要尝试使用或想象其他工具
   - 不要使用任何未在工具列表中列出的功能
   - 如果某个操作无法用现有工具完成，使用attempt_completion工具结束任务并说明原因

6. 任务完成条件：
   - 当完成用户初始请求的所有要求后，必须立即使用attempt_completion工具结束任务
   - 不要在没有完成用户初始请求的情况下继续执行其他操作
   - 不要重复执行已经完成的操作
   - 如果遇到需要用户提供额外信息的情况，使用show_options工具给出选项或使用attempt_completion工具等待用户输入，不能直接停止

7. 用户交互规则：
   - 当需要用户决定是否执行某些操作时，可以使用show_options工具向用户提供选项，也可以通过attempt_completion工具等待用户输入，不能直接停止
   - 只能通过show_options工具向用户提供选项
   - 只能通过attempt_completion工具等待用户输入
   - 不要在没有用户明确要求的情况下继续执行其他操作
   - 每次工具调用后必须等待结果，不要连续调用多个工具

8. 工具使用规则：
   - 每次只能调用一个工具，等待结果后再决定下一步
   - 对于需要用户确认的操作（如delete_file、execute_command），必须等待用户确认
   - 工具调用后必须立即结束当前回复，等待结果后再继续
   - 不要重复执行相同的工具调用
   - 不要尝试使用任何未在工具列表中列出的功能

9. 任务流程：
   - 首先分析用户需求，确定需要完成的具体任务
   - 使用list_files或search_files了解项目结构
   - 根据分析结果逐步执行任务
   - 如果需要用户提供信息，使用show_options或attempt_completion
   - 完成所有要求后立即使用attempt_completion结束任务
   - 如果某个操作无法用现有工具完成，使用attempt_completion结束任务

10. 错误处理：
    - 如果某个操作失败，最多尝试两次
    - 如果两次都失败，使用attempt_completion工具结束任务并说明原因
    - 不要陷入无限循环或重复尝试失败的操作
    - 如果发现无法用现有工具完成任务，立即使用attempt_completion结束任务

11. 回复格式示例：
    好的，让我先查看项目结构：
    <list_files>
    <directory>src</directory>
    <recursive>true</recursive>
    </list_files>
    
    我看到项目中有以下文件：
    - src/main.js
    - src/utils.js
    
    现在我需要查看main.js的内容：
    <read_file>
    <path>src/main.js</path>
    </read_file>
    
    文件内容显示这是一个React应用...

12. 任务结束条件：
    - 完成用户初始请求的所有要求
    - 遇到需要用户提供额外信息的情况
    - 遇到无法解决的问题
    - 达到最大尝试次数
    - 发现无法用现有工具完成任务

${historyContext}

${progressInfo}

你可以使用以下工具来完成任务（注意：你只能使用这些工具，不要尝试使用其他工具）：

## 系统工具（使用<工具名>...</工具名>格式调用）

## write_to_file
描述：创建或覆盖指定路径的文件
参数：
- path：文件路径（必须是相对于工作区根目录的路径，例如：src/main.js）
- content：文件内容
示例：
<write_to_file>
<path>src/example.js</path>
<content>console.log('Hello World');</content>
</write_to_file>

## read_file
描述：读取指定路径的文件内容
参数：
- path：文件路径（必须是相对于工作区根目录的路径，例如：src/main.js）
示例：
<read_file>
<path>src/example.js</path>
</read_file>

## replace_in_file
描述：在指定文件中替换文本
参数：
- path：文件路径（必须是相对于工作区根目录的路径，例如：src/main.js）
- old_text：要替换的文本
- new_text：替换后的文本
示例：
<replace_in_file>
<path>src/example.js</path>
<old_text>Hello World</old_text>
<new_text>Hello VSCode</new_text>
</replace_in_file>

## search_files
描述：使用正则表达式搜索文件
参数：
- pattern：正则表达式模式
- directory：搜索目录（必须是相对于工作区根目录的路径，例如：src）
- recursive：是否递归搜索，可选（默认为true）
示例：
<search_files>
<pattern>function\\s+main</pattern>
<directory>src</directory>
<recursive>true</recursive>
</search_files>

## list_files
描述：列出目录中的文件
参数：
- directory：目录路径（必须是相对于工作区根目录的路径，例如：src）
- recursive：是否递归列出，可选（默认为false）
示例：
<list_files>
<directory>src</directory>
<recursive>true</recursive>
</list_files>

## execute_command
描述：执行命令行命令
参数：
- command：要执行的命令
- requires_approval：是否需要用户批准（默认为true）
示例：
<execute_command>
<command>npm install lodash</command>
<requires_approval>true</requires_approval>
</execute_command>

## create_directory
描述：创建目录
参数：
- path：目录路径（必须是相对于工作区根目录的路径，例如：src/components）
示例：
<create_directory>
<path>src/components</path>
</create_directory>

## delete_file
描述：删除文件，需要用户确认
参数：
- path：文件路径（必须是相对于工作区根目录的路径，例如：src/old_file.js）
示例：
<delete_file>
<path>src/old_file.js</path>
</delete_file>

## rename_file
描述：重命名文件
参数：
- old_path：原文件路径（必须是相对于工作区根目录的路径，例如：src/old_name.js）
- new_path：新文件路径（必须是相对于工作区根目录的路径，例如：src/new_name.js）
示例：
<rename_file>
<old_path>src/old_name.js</old_path>
<new_path>src/new_name.js</new_path>
</rename_file>

## search_text
描述：在文件内容中搜索指定文本
参数：
- text：要搜索的文本
- file_pattern：文件模式，如 *.js（可选，默认为 *）
- directory：搜索目录（必须是相对于工作区根目录的路径，例如：src）
- recursive：是否递归搜索，可选（默认为true）
示例：
<search_text>
<text>function hello</text>
<file_pattern>*.js</file_pattern>
<directory>src</directory>
<recursive>true</recursive>
</search_text>

## show_options
描述：向用户展示选项列表并等待用户选择
参数：
- options：选项数组，使用逗号分隔
- message：展示给用户的提示信息（可选）
示例：
<show_options>
<options>使用React,使用Vue,使用Angular</options>
<message>请选择要使用的前端框架</message>
</show_options>

## attempt_completion
描述：标记任务为完成
参数：
- summary：任务完成摘要
示例：
<attempt_completion>
<summary>已经成功创建了所有需要的文件</summary>
</attempt_completion>

注意事项：
1. 每次使用工具调用后必须立即结束回复，等待结果后再继续
2. 完成用户初始请求后必须立即使用attempt_completion工具结束任务
3. 需要用户提供信息时，只能使用show_options或attempt_completion工具
4. 不要在没有完成用户初始请求的情况下继续执行其他操作
5. 不要重复执行已经完成的操作
6. 如果遇到问题，最多尝试两次，然后使用attempt_completion结束任务
7. 只能使用上面列出的工具，不要尝试使用其他工具
8. 如果发现无法用现有工具完成任务，立即使用attempt_completion结束任务
9. 每次回复必须包含文字说明，不能只调用工具
10. 在调用工具前必须说明这步要做什么
11. 在调用工具后必须说明工具执行的结果
12. 所有文件路径必须是相对于工作区根目录的路径
13. 如果搜索失败，使用list_files查看目录结构
14. 区分系统工具（<工具名>格式）和MCP工具（<mcp-tool>格式）
15. 如果需要用户决定是否执行某些操作时，可以使用show_options工具向用户提供选项，也可以通过attempt_completion工具等待用户输入，不能直接停止
16. 如果没有得到工具结果，请立即使用attempt_completion结束任务并说明信息

工作流程：
1. 分析用户需求，确定具体任务
2. 检查是否可以用现有工具完成任务
3. 使用工具逐步完成任务（每次都要说明目的和结果）
4. 需要用户输入时使用show_options或attempt_completion
5. 完成所有要求后立即使用attempt_completion结束任务
6. 如果发现无法用现有工具完成任务，立即使用attempt_completion结束任务
7. 如果搜索失败，使用list_files查看目录结构
8. 优先使用系统工具，只在必要时使用MCP工具

工作区信息：
${JSON.stringify(this.taskContext.workspaceInfo, null, 2)}

用户请求：
${this.taskContext.userPrompt}

活动编辑器信息：
${editorInfo}

请仔细分析需求，避免重复，并使用最适合的工具逐步完成任务。记住：
1. 你只能使用上面列出的工具，不要尝试使用其他工具
2. 每次回复必须包含文字说明，不能只调用工具
3. 在调用工具前必须说明这步要做什么
4. 在调用工具后必须说明工具执行的结果
5. 所有文件路径必须是相对于工作区根目录的路径
6. 如果搜索失败，使用list_files查看目录结构
7. 区分系统工具和MCP工具，选择最合适的工具类型
8. 优先使用系统工具，只在系统工具无法满足需求时使用MCP工具

${mcpToolsDescription}`;

        return systemPrompt;
    }

    /**
     * 停止当前任务
     */
    stopCurrentTask() {
        if (this.activeTaskId) {
            // 停止AI服务
            this.aiService.stopResponse();
            // 重置任务状态
            this.activeTaskId = null;
            this.currentTaskState.isRunning = false;
            this.currentTaskState.isCompleted = true;
            // 通知前端任务已停止
            if (this.currentTaskState.progressCallback) {
                this.currentTaskState.progressCallback({ 
                    type: 'system', 
                    message: '任务已停止' 
                });
            }
            return true;
        }
        return false;
    }

    /**
     * 处理工具调用的批准或拒绝
     * @param {string} toolId - 工具调用ID
     * @param {boolean} isApproved - 是否被批准
     * @param {string} additionalInput - 用户额外输入（可选）
     * @returns {Promise<Object>} - 处理结果
     */
    async handleToolApproval(toolId, isApproved, additionalInput = '') {
        try {
            // 查找当前待处理的工具调用
            const pendingTool = this.currentTaskState.partialMessages.get(toolId);
            if (!pendingTool) {
                return { 
                    success: false, 
                    error: `找不到ID为 ${toolId} 的工具调用` 
                };
            }
            
            if (isApproved) {
                // 用户批准了工具调用，提取并执行工具
                const assistantBlocks = this.parseAssistantMessage(pendingTool.content).toolCalls;
                const toolUseBlock = assistantBlocks.find(block => block.type === 'tool_use');
                
                if (!toolUseBlock) {
                    return { 
                        success: false, 
                        error: '无法解析工具调用' 
                    };
                }
                
                const toolCall = {
                    name: toolUseBlock.name,
                    params: toolUseBlock.params
                };
                
                // 如果用户提供了额外输入，可以在这里处理
                if (additionalInput && toolCall.params) {
                    // 例如，可能更新命令参数等
                    if (toolCall.name === 'execute_command' && toolCall.params.command) {
                        toolCall.params.command = additionalInput || toolCall.params.command;
                    }
                }
                
                // 执行工具调用
                const result = await this.executeToolCall(toolCall);
                
                // 更新任务上下文
                this.taskContext.results.push({
                    tool: toolCall.name,
                    params: toolCall.params,
                    result: result
                });
                
                // 添加工具响应到上下文
                this.taskContext.messages.push({
                    role: 'user',
                    content: JSON.stringify({
                        tool: toolCall.name,
                        result: result,
                        approved: true,
                        additionalInput: additionalInput || undefined
                    })
                });
                
                return {
                    success: result.success,
                    toolName: toolCall.name,
                    result: result
                };
            } else {
                // 用户拒绝了工具调用
                // 将拒绝信息添加到上下文
                this.taskContext.messages.push({
                    role: 'user',
                    content: JSON.stringify({
                        rejected: true,
                        feedback: additionalInput || '用户拒绝了操作',
                        toolId: toolId
                    })
                });
                
                return {
                    success: false,
                    rejected: true,
                    feedback: additionalInput
                };
            }
        } catch (error) {
            console.error('处理工具批准失败:', error);
            return {
                success: false,
                error: error.message
            };
        }
    }

    /**
     * 检查工具是否应该自动批准
     * @param {string} toolName - 工具名称
     * @param {string} path - 文件路径（可选）
     * @returns {boolean} - 是否自动批准
     */
    shouldAutoApproveTool(toolName, path) {
        // 默认情况下，安全工具可以自动批准
        const safeTools = ['read_file', 'search_files', 'search_text', 'list_files', 'list_code_definition_names'];
        
        // 如果工具名称在安全工具列表中
        if (safeTools.includes(toolName)) {
            return true;
        }
        
        // 非安全工具检查自动批准设置
        if (this.autoApprovalSettings?.enabled) {
            // 文件操作工具需要检查路径
            if (['write_to_file', 'replace_in_file', 'delete_file', 'rename_file'].includes(toolName) && path) {
                // 如果路径在允许列表中
                return this.autoApprovalSettings.paths.some(allowedPath => 
                    path.startsWith(allowedPath)
                );
            }
            
            // 其他工具类型可以在这里添加特定规则
        }
        
        // 默认不自动批准
        return false;
    }

    /**
     * 获取当前任务的完整消息列表，包括用户和AI的消息，便于保存到聊天记录
     * @returns {Array} 格式化后的消息数组，适用于聊天界面
     */
    getFormattedMessages() {
        const formattedMessages = [];
        
        if (!this.taskContext || !this.taskContext.messages) {
            return formattedMessages;
        }
        
        // 处理所有消息
        for (const message of this.taskContext.messages) {
            if (message.role === 'user') {
                // 处理用户消息
                if (typeof message.content === 'string') {
                    // 普通文本消息
                    formattedMessages.push({
                        sender: 'user',
                        text: message.content
                    });
                } else if (typeof message.content === 'object') {
                    // 工具结果消息，不显示在聊天界面
                    continue;
                }
            } else if (message.role === 'assistant') {
                // 处理AI助手消息
                if (typeof message.content === 'string') {
                    formattedMessages.push({
                        sender: 'bot',
                        text: message.content
                    });
                }
            }
        }
        
        return formattedMessages;
    }

    /**
     * 创建消息（直接调用模型获取回复）
     * @param {string} systemPrompt - 系统提示词
     * @param {Array} messages - 消息历史
     * @param {Function} onData - 数据回调函数
     * @returns {Promise<string>} - 任务ID
     */
    async createMessage(systemPrompt, messages, onData) {
        // 获取模型信息
        const model = this.selectedModel || "qwen-plus";
        
        // 构建上下文
        const context = {
            systemPrompt,
            messages,
            model,
            enableReasoning: this.enableReasoning !== undefined ? this.enableReasoning : true,
            sendThinking: true,
        };
        
        // 调用streamResponse处理消息
        return await this.aiService.streamResponse(null, context, onData);
    }

    // 新增：供前端调用，用户同意/拒绝后继续任务
    async handleUserApproval(approved, additionalInput = '', selectedOption = null) {
        if (this.waitingForUser && this.waitingForUser.resolve) {
            const toolName = this.waitingForUser.toolCall.name;
            
            // 定义需要用户确认的高风险操作
            const dangerousTools = ['execute_command', 'delete_file'];
            
            // 处理选项工具的用户选择
            if (toolName === 'show_options' && selectedOption !== null) {
                // 用户已选择，处理结果
                const result = {
                    success: true,
                    message: "用户已选择选项",
                    selectedOption: selectedOption,
                    selectedIndex: Array.isArray(this.waitingForUser.toolCall.params.options) 
                        ? this.waitingForUser.toolCall.params.options.indexOf(selectedOption)
                        : -1
                };
                
                // 确保选项结果正确格式化并添加到上下文
                const optionsData = {
                    tool: 'show_options',
                    params: this.waitingForUser.toolCall.params,
                    result: result
                };
                
                // 添加选项结果到上下文，确保它是正确的用户消息格式
                this.taskContext.messages.push({
                    role: 'user',
                    content: JSON.stringify(optionsData)
                });
                
                // 通知AI用户的选择
                this.taskContext.messages.push({
                    role: 'system',
                    content: `用户选择了选项：${selectedOption}`
                });
                
                console.log("选项结果已添加到上下文：", JSON.stringify(optionsData));
                
                this.waitingForUser.resolve(result);
            } else {
                // 处理普通操作工具
                if (approved) {
                    // 用户同意，执行工具
                    const result = await this._actuallyDoTool(this.waitingForUser.toolCall);
                    
                    // 添加工具执行结果到上下文
                    this.taskContext.messages.push({
                        role: 'function',
                        content: JSON.stringify({
                            type: 'tool_result',
                            tool: this.waitingForUser.toolCall.name,
                            params: this.waitingForUser.toolCall.params,
                            approved: true,
                            result: result
                        })
                    });

                    this.waitingForUser.resolve(result);
                } else {
                    // 用户拒绝
                    const result = { 
                        success: false, 
                        error: additionalInput || '用户拒绝了操作'
                    };

                    // 添加用户拒绝信息到上下文
                    this.taskContext.messages.push({
                        role: 'function',
                        content: JSON.stringify({
                            type: 'tool_result',
                            tool: this.waitingForUser.toolCall.name,
                            params: this.waitingForUser.toolCall.params,
                            approved: false,
                            error: additionalInput || '用户拒绝了操作'
                        })
                    });

                    this.waitingForUser.resolve(result);
                }
            }

            // 恢复循环
            if (this.waitingForUser.resume) {
                this.waitingForUser.resume();
            }
            this.waitingForUser = null;
        }

        // 处理MCP工具批准
        if (this._lastMcpApprovalCallback && typeof this._lastMcpApprovalCallback === 'function') {
            try {
                console.log(`[MCP批准] 开始处理MCP工具批准: ${approved ? '已批准' : '已拒绝'}`);
                console.log(`[MCP批准] 当前任务上下文消息数量: ${this.taskContext.messages.length}`);
                
                this._lastMcpApprovalCallback(approved);
                
                // 清除回调
                this._lastMcpApprovalCallback = null;
                
                // 通知前端
                this.currentTaskState.progressCallback({
                    type: 'system',
                    message: `MCP工具${approved ? '已批准，执行中...' : '已拒绝'}`
                });
                
                // 添加批准或拒绝信息到上下文
                const approvalMessage = {
                        role: 'system',
                    content: approved ? '用户批准了MCP工具调用' : (additionalInput || '用户拒绝了MCP工具调用')
                };
                
                console.log(`[MCP批准] 准备添加消息到上下文:`, approvalMessage);
                this.taskContext.messages.push(approvalMessage);
                console.log(`[MCP批准] 添加消息后上下文消息数量: ${this.taskContext.messages.length}`);
                    
                // 如果拒绝了工具调用，清除待处理的MCP响应
                if (!approved) {
                    console.log(`[MCP批准] 用户拒绝，清除待处理的MCP响应`);
                    this._pendingMcpResponse = null;
                }
                
                // 打印当前所有消息
                console.log(`[MCP批准] 当前所有消息:`, this.taskContext.messages);
            } catch (error) {
                console.error('[MCP批准] 处理MCP工具批准失败:', error);
                
                // 通知前端
                this.currentTaskState.progressCallback({
                    type: 'error',
                    message: `处理MCP工具批准失败: ${error.message}`
                });
                
                // 清除回调和待处理响应
                this._lastMcpApprovalCallback = null;
                this._pendingMcpResponse = null;
            }
        }
    }

    // 实际执行工具调用（原有switch逻辑抽出来）
    async _actuallyDoTool(toolCall) {
        const { name, params } = toolCall;
        try {
            switch (name) {
                case 'write_to_file':
                    return await this.tools.writeToFile(params.path, params.content);
                case 'read_file':
                    return await this.tools.readFile(params.path);
                case 'replace_in_file':
                    return await this.tools.replaceInFileWithDiff(params.path, params.old_text, params.new_text);
                case 'search_files':
                    return await this.tools.searchFiles(params.pattern, params.directory, params.recursive === 'true');
                case 'search_text':
                    return await this.tools.searchText(params.text, params.file_pattern, params.directory, params.recursive === 'true');
                case 'list_files':
                    return await this.tools.listFiles(params.directory, params.recursive === 'true');
                case 'execute_command':
                    return await this.tools.executeCommand(params.command);
                case 'create_directory':
                    return await this.tools.createDirectory(params.path);
                case 'delete_file':
                    return await this.tools.deleteFile(params.path);
                case 'rename_file':
                    return await this.tools.renameFile(params.old_path, params.new_path);
                case 'show_options':
                    return await this.tools.showOptionsToUser(params.options, params.message);
                case 'attempt_completion':
                    return { success: true, message: '任务完成' };
                default:
                    return { success: false, error: `未知的工具调用: ${name}` };
            }
        } catch (error) {
            return { success: false, error: error.message };
        }
    }
}

module.exports = AgentTask; 